﻿#include "connectmanager.h"

ConnectManager::ConnectManager(QObject *parent)
    : QObject{parent}
{
    // 设置数据库驱动
    deviceSql = QSqlDatabase::addDatabase("QSQLITE");
    // 设置数据库名称
    deviceSql.setDatabaseName("./DeviceParameter.db");

    if(deviceSql.open())
    {
        qDebug()<<"Cpp:设备连接参数数据库打开成功";

        QSqlQuery query;

        query.prepare("CREATE TABLE IF NOT EXISTS LinkMachineParameter\
                        (ModBusTCP_IP TEXT,ModBusTCP_PortName TEXT,\
                        PrinterPortName TEXT,PrinterBaudRate TEXT,PrinterDataBite TEXT,PrinterParity TEXT,PrinterStopBite TEXT,\
                      ScannerPortName TEXT,ScannerBaudRate TEXT,ScannerDataBite TEXT,ScannerParity TEXT,ScannerStopBite TEXT)");

        if(!query.exec())
        {
            qDebug()<<"Cpp:创建设备连接参数表格失败"<<query.lastError().text();
        }

        qDebug()<<deviceSql.tables();
    }
    else
    {
        qDebug()<<"Cpp:设备连接参数数据库打开失败"<<deviceSql.lastError().text();
    }



    // 从数据库读取最新一条配置参数
    readLastParamter();

    // ModBusTCP 连接
    modbusConnect->connectToPLC();    

    // 打印机 连接
    printerConnect->linkToComputer();

    // 扫码枪 连接
    scannerConnect->linkToComputer();    

    timer->setInterval(300);
    // 连接定时器响应槽函数
    QObject::connect(timer,SIGNAL(timeout()),this,SLOT(onTimeOut_Slots()));

    timer->start();

    // 连接状态
    QObject::connect(modbusConnect->modbusClient,SIGNAL(stateChanged(QModbusDevice::State)),this,SLOT(onModbusStateChanged_Slots(QModbusDevice::State)));
    // 扫码枪扫描结果
    QObject::connect(scannerConnect->scannerSerial,SIGNAL(readyRead()),this,SLOT(onScannerResult_Slots()));

    //初始化报警数据
    initWarnData();

}

ConnectManager::~ConnectManager()
{

}

void ConnectManager::getParamaterFromQML(QString ip, QString port,
                                         QString printerPortName,QString printerBaudRate,QString printerDataBite,QString printerParity,QString printerStopBite,
                                         QString scannerPortName,QString scannerBaudRate,QString scannerDataBite,QString scannerParity,QString scannerStopBite)
{

    // 保存到数据库
    saveParameterIntoDataBase(ip,port,
                                printerPortName.section(':',0,0),printerBaudRate,printerDataBite,printerParity,printerStopBite,
                              scannerPortName.section(':',0,0),scannerBaudRate,scannerDataBite,scannerParity,scannerStopBite);


    // ModBusTCP 设置连接参数
    modbusConnect->setConnectParameter(ip,port);
    // ModBusTCP 连接
    modbusConnect->connectToPLC();
    //打印机 设置连接参数
    printerConnect->setConnectParameter(printerPortName.section(':',0,0),
                                        printerBaudRate,
                                        printerDataBite,
                                        printerParity,
                                        printerStopBite);
    //打印机 连接
    printerConnect->linkToComputer();
    //扫码枪 设置连接参数
    scannerConnect->setConnectParameter(scannerPortName.section(':',0,0),
                                        scannerBaudRate,
                                        scannerDataBite,
                                        scannerParity,
                                        scannerStopBite);
    //扫码枪 连接
    scannerConnect->linkToComputer();
}

void ConnectManager::saveParameterIntoDataBase(QString ip, QString port,
                                               QString printerPortName, QString printerBaudRate, QString printerDataBite, QString printerParity, QString printerStopBite,
                                               QString scannerPortName, QString scannerBaudRate, QString scannerDataBite, QString scannerParity, QString scannerStopBite)
{
    QString saveStr = QString("INSERT INTO LinkMachineParameter (ModBusTCP_IP,ModBusTCP_PortName,\
                                                                PrinterPortName,PrinterBaudRate,PrinterDataBite,PrinterParity,PrinterStopBite,\
                                                                ScannerPortName,ScannerBaudRate,ScannerDataBite,ScannerParity,ScannerStopBite) \
                                                                VALUES ('%1','%2','%3','%4','%5','%6','%7','%8','%9','%10','%11','%12')")
                                                                .arg(ip).arg(port)
                                                                .arg(printerPortName).arg(printerBaudRate).arg(printerDataBite).arg(printerParity).arg(printerStopBite)
                                                                .arg(scannerPortName).arg(scannerBaudRate).arg(scannerDataBite).arg(scannerParity).arg(scannerStopBite);

    QSqlQuery query;

    query.prepare(saveStr);

    if(!query.exec())
    {
        qDebug()<<"Cpp -- 保存参数到数据库失败！！"<<query.lastError().text();
    }
    else
    {
        qDebug()<<"Cpp -- 保存参数到数据库成功";
    }
}

void ConnectManager::automaticPanel_OneKeyWriteParameter(QString knife, QString roller, QString stress01, QString stress02, QString stress03,
                                                         QString fwdknife01, QString fwdknife02, QString fwdknife03, QString backknife01, QString backknife02, QString backknife03)
{
    modbusConnect->AutomaticPanel_OneKeyWriteParameter(knife,roller,stress01,stress02,stress03,fwdknife01,fwdknife02,fwdknife03,backknife01,backknife02,backknife03);
}

void ConnectManager::getCurrentLocationOnce()
{
    modbusConnect->readCurrentLocation();
    setKnifeCurrLocation(modbusConnect->knife_CurrLocation);
    setRollerCurrLocation(modbusConnect->roller_CurrLocation);
    setStress01CurrLocation(modbusConnect->stress01_CurrLocation);
    setStress02CurrLocation(modbusConnect->stress02_CurrLocation);
    setStress03CurrLocation(modbusConnect->stress03_CurrLocation);
    setF_knife01CurrLocation(modbusConnect->f_knife01_CurrLocation);
    setF_knife02CurrLocation(modbusConnect->f_knife02_CurrLocation);
    setF_knife03CurrLocation(modbusConnect->f_knife03_CurrLocation);
    setB_knife01CurrLocation(modbusConnect->b_knife01_CurrLocation);
    setB_knife02CurrLocation(modbusConnect->b_knife02_CurrLocation);
    setB_knife03CurrLocation(modbusConnect->b_knife03_CurrLocation);
}

void ConnectManager::write_modbus_tcp_OneHoldingRegisters(QString address, QString newValue)
{
    modbusConnect->write_modbus_tcp_HoldingRegisters(address,newValue);
}

void ConnectManager::write_modbus_tcp_TwoHoldingResgisters(QString address, QString newValue)
{
    modbusConnect->write_modbus_tcp_HoldingRegisters_DW(address,newValue);
}

void ConnectManager::scanAvailableInfo()
{
    m_serialInfo.clear();		// 清空列表

    // 自动扫描当前可用串口，返回值追加到字符数组中
    foreach(const QSerialPortInfo &info, QSerialPortInfo::availablePorts()){

        // 携带有串口设备信息的文本
        QString serialPortInfo = info.portName() + ": " + info.description();
        // 串口设备信息，芯片/驱动名称
        m_serialInfo << serialPortInfo;
    }

    emit serialInfoChanged();
}

void ConnectManager::readLastParamter()
{
    QString readStr = QString("SELECT * FROM LinkMachineParameter ORDER BY rowid DESC LIMIT 1");

    QSqlQuery query;

    query.prepare(readStr);

    if(!query.exec())
    {
        qDebug()<<"Cpp:输出数据库最后一条数据失败";
    }
    else
    {
        while(query.next())
        {

            // 配置 ModBusTCP 连接参数
            modbusConnect->setConnectParameter(query.value(0).toString(),
                                               query.value(1).toString());

            // 配置 打印机 连接参数
            printerConnect->setConnectParameter(query.value(2).toString(),
                                                query.value(3).toString(),
                                                query.value(4).toString(),
                                                query.value(5).toString(),
                                                query.value(6).toString());

            //配置 扫码枪 连接参数
            scannerConnect->setConnectParameter(query.value(7).toString(),
                                                query.value(8).toString(),
                                                query.value(9).toString(),
                                                query.value(10).toString(),
                                                query.value(11).toString());
        }
    }
}

void ConnectManager::printerActive(bool flag,QString company = "" , QString nameData= "",QString numberData= "",
                                   QString knife= "",QString roller= "",
                                   QString stress01= "",QString stress02= "",QString stress03= "",
                                   QString fwdknife01= "",QString fwdknife02= "",QString fwdknife03= "",
                                   QString backknife01= "",QString backknife02= "",QString backknife03 = "")
{
    if(flag)
    {
        printerConnect->printerActive_WH(company ,  nameData, numberData,
                                          knife, roller,
                                          stress01, stress02, stress03,
                                          fwdknife01, fwdknife02, fwdknife03,
                                          backknife01, backknife02, backknife03);
    }
    else if(!flag)
    {
        printerConnect->printerActive_RG(company , nameData, numberData,
                                         knife, roller,
                                         stress01, stress02, stress03,
                                         fwdknife01, fwdknife02, fwdknife03,
                                         backknife01, backknife02, backknife03);
    }

}

void ConnectManager::initWarnData()
{
    // 初始化信号数据，开始时全部置为 false
    for(int i = 0 ;  i  < 27 ;++i)
    {
        m_warnVector.append(false);
        m_newWarnVector.append(false);
    }

    // 定义信号对应的详细报警信息描述
    m_warnDetail.insert(0,"刀盘上行软限位");
    m_warnDetail.insert(1,"刀盘下行软限位");
    m_warnDetail.insert(2," 胶辊上行软限位");
    m_warnDetail.insert(3," 胶辊下行软限位");
    m_warnDetail.insert(4," 压力1前进软限位");
    m_warnDetail.insert(5," 压力1后退软限位");
    m_warnDetail.insert(6," 压力2前进软限位");
    m_warnDetail.insert(7," 压力2后退软限位");
    m_warnDetail.insert(8," 压力3前进软限位");
    m_warnDetail.insert(9," 压力3后退软限位");
    m_warnDetail.insert(10," 前刀1上行软限位");
    m_warnDetail.insert(11," 前刀1下行软限位");
    m_warnDetail.insert(12," 前刀2上行软限位");
    m_warnDetail.insert(13," 前刀2下行软限位");
    m_warnDetail.insert(14," 前刀3上行软限位");
    m_warnDetail.insert(15," 前刀3下行软限位");
    m_warnDetail.insert(16," 后刀1上行软限位");
    m_warnDetail.insert(17," 后刀1下行软限位");
    m_warnDetail.insert(18," 后刀2上行软限位");
    m_warnDetail.insert(19," 后刀2下行软限位");
    m_warnDetail.insert(20," 后刀3上行软限位");
    m_warnDetail.insert(21," 后刀3下行软限位");
    m_warnDetail.insert(22," 胶辊原点");
    m_warnDetail.insert(23," 刀盘上限位");
    m_warnDetail.insert(24," 刀盘下限位");
    m_warnDetail.insert(25," 变频器报警");
    m_warnDetail.insert(26," 报警信号");
}

void ConnectManager::readNewWarningData()
{
    for(int i = 0 ; i < m_warnVector.size() ; i++)
    {
        switch (i) {
        case 0:
            m_newWarnVector[i]=m_knife_Up_SLmt;
            break;
        case 1:
            m_newWarnVector[i]=m_knife_Down_SLmt;
            break;
        case 2:
            m_newWarnVector[i]=m_roller_Up_SLmt;
            break;
        case 3:
            m_newWarnVector[i]=m_roller_Down_SLmt;
            break;
        case 4:
            m_newWarnVector[i]=m_stress01_F_SLmt;
            break;
        case 5:
            m_newWarnVector[i]=m_stress01_B_SLmt;
            break;
        case 6:
            m_newWarnVector[i]=m_stress02_F_SLmt;
            break;
        case 7:
            m_newWarnVector[i]=m_stress02_B_SLmt;
            break;
        case 8:
            m_newWarnVector[i]=m_stress03_F_SLmt;
            break;
        case 9:
            m_newWarnVector[i]=m_stress03_B_SLmt;
            break;
        case 10:
            m_newWarnVector[i]=m_f_knife01_Up_SLmt;
            break;
        case 11:
            m_newWarnVector[i]=m_f_knife01_Down_SLmt;
            break;
        case 12:
            m_newWarnVector[i]=m_f_knife02_Up_SLmt;
            break;
        case 13:
            m_newWarnVector[i]=m_f_knife02_Down_SLmt;
            break;
        case 14:
            m_newWarnVector[i]=m_f_knife03_Up_SLmt;
            break;
        case 15:
            m_newWarnVector[i]=m_f_knife03_Down_SLmt;
            break;
        case 16:
            m_newWarnVector[i]=m_b_knife01_Up_SLmt;
            break;
        case 17:
            m_newWarnVector[i]=m_b_knife01_Down_SLmt;
            break;
        case 18:
            m_newWarnVector[i]=m_b_knife02_Up_SLmt;
            break;
        case 19:
            m_newWarnVector[i]=m_b_knife02_Down_SLmt;
            break;
        case 20:
            m_newWarnVector[i]=m_b_knife03_Up_SLmt;
            break;
        case 21:
            m_newWarnVector[i]=m_b_knife03_Down_SLmt;
            break;
        case 22:
            m_newWarnVector[i]=m_rollerOrigin;
            break;
        case 23:
            m_newWarnVector[i]=m_knifeUpLmt;
            break;
        case 24:
            m_newWarnVector[i]=m_knifeDownLmt;
            break;
        case 25:
            m_newWarnVector[i]=m_transducerWarnning;
            break;
        case 26:
            m_newWarnVector[i]=m_warnningSignal;
            break;
        default:
            break;
        }
    }

    // for(int i=0;i<m_newWarnVector.size();i++)
    // {
    //     qDebug()<<"m_newWarnVector "
    //              <<QString::number(i)<<": "<<m_newWarnVector[i];
    // }


    // 保存报警信息
    saveWarningInfo();
}

void ConnectManager::readWarningSignal()
{
    foreachHistory();

    m_warnInfo = "现在报警信号:";

    for(int i=0;i<m_warnVector.size();i++)
    {
        switch (i) {
        case 0:
            getWarningDetailInfo(i);
            break;
        case 1:
            getWarningDetailInfo(i);
            break;
        case 2:
            getWarningDetailInfo(i);
            break;
        case 3:
            getWarningDetailInfo(i);
            break;
        case 4:
            getWarningDetailInfo(i);
            break;
        case 5:
            getWarningDetailInfo(i);
            break;
        case 6:
            getWarningDetailInfo(i);
            break;
        case 7:
            getWarningDetailInfo(i);
            break;
        case 8:
            getWarningDetailInfo(i);
            break;
        case 9:
            getWarningDetailInfo(i);
            break;
        case 10:
            getWarningDetailInfo(i);
            break;
        case 11:
            getWarningDetailInfo(i);
            break;
        case 12:
            getWarningDetailInfo(i);
            break;
        case 13:
            getWarningDetailInfo(i);
            break;
        case 14:
            getWarningDetailInfo(i);
            break;
        case 15:
            getWarningDetailInfo(i);
            break;
        case 16:
            getWarningDetailInfo(i);
            break;
        case 17:
            getWarningDetailInfo(i);
            break;
        case 18:
            getWarningDetailInfo(i);
            break;
        case 19:
            getWarningDetailInfo(i);
            break;
        case 20:
            getWarningDetailInfo(i);
            break;
        case 21:
            getWarningDetailInfo(i);
            break;
        case 22:
            getWarningDetailInfo(i);
            break;
        case 23:
            getWarningDetailInfo(i);
            break;
        case 24:
            getWarningDetailInfo(i);
            break;
        case 25:
            getWarningDetailInfo(i);
            break;
        case 26:
            getWarningDetailInfo(i);
            break;
        default:
            break;
        }
    }

    emit sig_WarningSignalChanged(m_warnInfo);
}

void ConnectManager::getWarningDetailInfo(int index)
{
    if(m_warnVector[index] == true)
    {
        m_warnInfo = m_warnInfo + m_warnDetail[index];
    }
}

void ConnectManager::saveWarningInfo()
{
    QDateTime currentTime = QDateTime::currentDateTime();

    // 格式化日期为 "yyyy-MM-dd" 格式
    QString formattedDate = currentTime.date().toString("yyyy-MM-dd");

    // 格式化时间为 "HH:mm:ss"  格式
    QString formattedTime = currentTime.time().toString("HH:mm:ss");

    for(int i = 0 ; i < m_warnVector.size() ; ++i)
    {
        // 如果信号发生变化
        if(m_warnVector[i] != m_newWarnVector[i])
        {
            // 判断报警信号产生还是消除
            if(m_warnVector[i] == true)
            {
                qDebug()<<"第 "<<QString::number(i)<<" 位消除报警";

                for(int j = 0 ; j < m_warnHistory.size(); ++j)
                {
                    if(m_warnHistory.at(j).discription == m_warnDetail[i] && m_warnHistory.at(j).endTime == "报警中")
                    {
                        WARNSIGNALINFO warnInfo;
                        warnInfo.startDateTime = m_warnHistory.at(j).startDateTime;
                        warnInfo.startDate = m_warnHistory.at(j).startDate;
                        warnInfo.startTime = m_warnHistory.at(j).startTime;
                        warnInfo.discription = m_warnHistory.at(j).discription;
                        warnInfo.endTime = formattedTime;

                        // 计算两个日期时间之间的秒数差
                        int secondsDifference = warnInfo.startDateTime.secsTo(currentTime);
                        int hours = secondsDifference / 3600;
                        int minutes = (secondsDifference % 3600) / 60;
                        int seconds = secondsDifference % 60;

                        QString durationtime = QString("%1:%2:%3")
                                                   .arg(hours,2,10,QLatin1Char('0'))
                                                   .arg(minutes,2,10,QLatin1Char('0'))
                                                   .arg(seconds,2,10,QLatin1Char('0'));

                        warnInfo.durationtime = durationtime;

                        qDebug()<<"warnInfo.durationtime:"<<warnInfo.durationtime;

                        m_warnHistory.replace(j,warnInfo);

                    }
                }
            }
            else
            {
                qDebug()<<"第 "<<QString::number(i)<<" 位发生报警";

                WARNSIGNALINFO warnInfo;
                warnInfo.startDateTime = currentTime;
                warnInfo.startDate = formattedDate;
                warnInfo.startTime = formattedTime;
                warnInfo.discription = m_warnDetail[i];
                warnInfo.endTime = "报警中";
                m_warnHistory.append(warnInfo);
            }

            m_warnVector[i] = m_newWarnVector[i];

        }
    }


    QVariantList historyList;
    for(int i = 0 ; i < m_warnHistory.size() ; ++i)
    {
        //将自定义信息转换位 QVariantMap 以便被 QML 解析
        QVariantMap map;
        map.insert("startDate", m_warnHistory[i].startDate);
        map.insert("startTime", m_warnHistory.at(i).startTime);
        map.insert("discription", m_warnHistory.at(i).discription);
        map.insert("endTime", m_warnHistory.at(i).endTime);
        map.insert("durationtime", m_warnHistory.at(i).durationtime);
        historyList.append(map);
    }

    emit sig_WarningHistoryDataChanged(historyList);

    readWarningSignal();

}

void ConnectManager::foreachHistory()
{
    for(int i = 0 ; i < m_warnHistory.size(); ++i)
    {
        qDebug()<<"--------------------"<<QString::number(i)<<"--------------------";
        qDebug()<<"startDateTime:"<<m_warnHistory.at(i).startDateTime;
        qDebug()<<"startDate:"<<m_warnHistory.at(i).startDate;
        qDebug()<<"startTime:"<<m_warnHistory.at(i).startTime;
        qDebug()<<"discription:"<<m_warnHistory.at(i).discription;
        qDebug()<<"endtime:"<<m_warnHistory.at(i).endTime;
        qDebug()<<"durationTime:"<<m_warnHistory.at(i).durationtime;
    }
}


QStringList ConnectManager::serialInfo() const
{
    return m_serialInfo;
}

void ConnectManager::setSerialInfo(const QStringList &newSerialInfo)
{
    if (m_serialInfo == newSerialInfo)
        return;
    m_serialInfo = newSerialInfo;
    emit serialInfoChanged();
}

bool ConnectManager::modbusState() const
{
    return m_modbusState;
}

void ConnectManager::setModbusState(bool newModbusState)
{
    if (m_modbusState == newModbusState)
        return;
    m_modbusState = newModbusState;
    emit modbusStateChanged();
}

void ConnectManager::onTimeOut_Slots()
{
    // qDebug()<<"读取报警参数";
    // modbusConnect->readWarningSignal();

    setKnife_Up_SLmt(modbusConnect->knife_Up_SLmt);
    setKnife_Down_SLmt(modbusConnect->knife_Down_SLmt);
    setRoller_Up_SLmt(modbusConnect->roller_Up_SLmt);
    setRoller_Down_SLmt(modbusConnect->roller_Down_SLmt);
    setStress01_F_SLmt(modbusConnect->stress01_F_SLmt);
    setStress01_B_SLmt(modbusConnect->stress01_B_SLmt);
    setStress02_F_SLmt(modbusConnect->stress02_F_SLmt);
    setStress02_B_SLmt(modbusConnect->stress02_B_SLmt);
    setStress03_F_SLmt(modbusConnect->stress03_F_SLmt);
    setStress03_B_SLmt(modbusConnect->stress03_B_SLmt);
    setF_knife01_Up_SLmt(modbusConnect->f_knife01_Up_SLmt);
    setF_knife01_Down_SLmt(modbusConnect->f_knife01_Down_SLmt);
    setF_knife02_Up_SLmt(modbusConnect->f_knife02_Up_SLmt);
    setF_knife02_Down_SLmt(modbusConnect->f_knife02_Down_SLmt);
    setF_knife03_Up_SLmt(modbusConnect->f_knife03_Up_SLmt);
    setF_knife03_Down_SLmt(modbusConnect->f_knife03_Down_SLmt);
    setB_knife01_Up_SLmt(modbusConnect->b_knife01_Up_SLmt);
    setB_knife01_Down_SLmt(modbusConnect->b_knife01_Down_SLmt);
    setB_knife02_Up_SLmt(modbusConnect->b_knife02_Up_SLmt);
    setB_knife02_Down_SLmt(modbusConnect->b_knife02_Down_SLmt);
    setB_knife03_Up_SLmt(modbusConnect->b_knife03_Up_SLmt);
    setB_knife03_Down_SLmt(modbusConnect->b_knife03_Down_SLmt);

    // modbusConnect->readIO_DisInput();

    setRollerOrigin(modbusConnect->rollerOrigin);
    setKnifeUpLmt(modbusConnect->knifeUpLmt);
    setKnifeDownLmt(modbusConnect->knifeDownLmt);
    setTransducerWarnning(modbusConnect->transducerWarnning);

    // modbusConnect->readIO_Coils();
    setWarnningSignal(modbusConnect->warnningSignal);

    //读取新出现的报警信号
    // readNewWarningData();

    switch (qmlPage()) {
    case 1:     // 自动加工界面
    {
        // qDebug()<<"读取当前位置";
        modbusConnect->readCurrentLocation();
        setKnifeCurrLocation(modbusConnect->knife_CurrLocation);
        setRollerCurrLocation(modbusConnect->roller_CurrLocation);
        setStress01CurrLocation(modbusConnect->stress01_CurrLocation);
        setStress02CurrLocation(modbusConnect->stress02_CurrLocation);
        setStress03CurrLocation(modbusConnect->stress03_CurrLocation);
        setF_knife01CurrLocation(modbusConnect->f_knife01_CurrLocation);
        setF_knife02CurrLocation(modbusConnect->f_knife02_CurrLocation);
        setF_knife03CurrLocation(modbusConnect->f_knife03_CurrLocation);
        setB_knife01CurrLocation(modbusConnect->b_knife01_CurrLocation);
        setB_knife02CurrLocation(modbusConnect->b_knife02_CurrLocation);
        setB_knife03CurrLocation(modbusConnect->b_knife03_CurrLocation);
        // qDebug()<<"读取目标位置";
        modbusConnect->readAimLocation();
        setKnifeAimLocation(modbusConnect->knife_AimLocation);
        setRollerAimLocation(modbusConnect->roller_AimLocation);
        setStress01AimLocation(modbusConnect->stress01_AimLocation);
        setStress02AimLocation(modbusConnect->stress02_AimLocation);
        setStress03AimLocation(modbusConnect->stress03_AimLocation);
        setF_knife01AimLocation(modbusConnect->f_knife01_AimLocation);
        setF_knife02AimLocation(modbusConnect->f_knife02_AimLocation);
        setF_knife03AimLocation(modbusConnect->f_knife03_AimLocation);
        setB_knife01AimLocation(modbusConnect->b_knife01_AimLocation);
        setB_knife02AimLocation(modbusConnect->b_knife02_AimLocation);
        setB_knife03AimLocation(modbusConnect->b_knife03_AimLocation);
        // qDebug()<<"读取变频器速度";
        modbusConnect->readTransducerSpeed();
        setTransducerSpeed(modbusConnect->transducerSpeed);
        break;
    }
    case 2:     // 单轴回待命点界面
        // qDebug()<<"读取当前位置";
        modbusConnect->readCurrentLocation();
        setKnifeCurrLocation(modbusConnect->knife_CurrLocation);
        setRollerCurrLocation(modbusConnect->roller_CurrLocation);
        setStress01CurrLocation(modbusConnect->stress01_CurrLocation);
        setStress02CurrLocation(modbusConnect->stress02_CurrLocation);
        setStress03CurrLocation(modbusConnect->stress03_CurrLocation);
        setF_knife01CurrLocation(modbusConnect->f_knife01_CurrLocation);
        setF_knife02CurrLocation(modbusConnect->f_knife02_CurrLocation);
        setF_knife03CurrLocation(modbusConnect->f_knife03_CurrLocation);
        setB_knife01CurrLocation(modbusConnect->b_knife01_CurrLocation);
        setB_knife02CurrLocation(modbusConnect->b_knife02_CurrLocation);
        setB_knife03CurrLocation(modbusConnect->b_knife03_CurrLocation);
        // qDebug()<<"待命点位置";
        modbusConnect->readStandbyLocation();
        setKnifeStandby(modbusConnect->knife_StandbyLocation);
        setRollerStandby(modbusConnect->roller_StandbyLocation);
        setStress01Standby(modbusConnect->stress01_StandbyLocation);
        setStress02Standby(modbusConnect->stress02_StandbyLocation);
        setStress03Standby(modbusConnect->stress03_StandbyLocation);
        setF_knife01Standby(modbusConnect->f_knife01_StandbyLocation);
        setF_knife02Standby(modbusConnect->f_knife02_StandbyLocation);
        setF_knife03Standby(modbusConnect->f_knife03_StandbyLocation);
        setB_knife01Standby(modbusConnect->b_knife01_StandbyLocation);
        setB_knife02Standby(modbusConnect->b_knife02_StandbyLocation);
        setB_knife03Standby(modbusConnect->b_knife03_StandbyLocation);
        break;
    case 3:     // 手动操作界面
        // qDebug()<<"读取当前位置";
        modbusConnect->readCurrentLocation();
        setKnifeCurrLocation(modbusConnect->knife_CurrLocation);
        setRollerCurrLocation(modbusConnect->roller_CurrLocation);
        setStress01CurrLocation(modbusConnect->stress01_CurrLocation);
        setStress02CurrLocation(modbusConnect->stress02_CurrLocation);
        setStress03CurrLocation(modbusConnect->stress03_CurrLocation);
        setF_knife01CurrLocation(modbusConnect->f_knife01_CurrLocation);
        setF_knife02CurrLocation(modbusConnect->f_knife02_CurrLocation);
        setF_knife03CurrLocation(modbusConnect->f_knife03_CurrLocation);
        setB_knife01CurrLocation(modbusConnect->b_knife01_CurrLocation);
        setB_knife02CurrLocation(modbusConnect->b_knife02_CurrLocation);
        setB_knife03CurrLocation(modbusConnect->b_knife03_CurrLocation);
        // qDebug()<<"读取定位位置";
        modbusConnect->readLocation();
        setKnifeLocation(modbusConnect->knife_Location);
        setRollerLocation(modbusConnect->roller_Location);
        setStress01Location(modbusConnect->stress01_Location);
        setStress02Location(modbusConnect->stress02_Location);
        setStress03Location(modbusConnect->stress03_Location);
        setF_knife01Location(modbusConnect->f_knife01_Location);
        setF_knife02Location(modbusConnect->f_knife02_Location);
        setF_knife03Location(modbusConnect->f_knife03_Location);
        setB_knife01Location(modbusConnect->b_knife01_Location);
        setB_knife02Location(modbusConnect->b_knife02_Location);
        setB_knife03Location(modbusConnect->b_knife03_Location);
        // qDebug()<<"读取变频器速度";
        modbusConnect->readTransducerSpeed();
        setTransducerSpeed(modbusConnect->transducerSpeed);
        // qDebug()<<"读取手动速率比例";
        modbusConnect->readManualSpeedRate();
        setManualSpeedRate(modbusConnect->manualSpeedRate);
        break;
    case 4:     // 配方设置界面
        // qDebug()<<"处于配方设置界面";
        break;
    case 5:     // 输入输出界面
        // qDebug()<<"处于输入输出界面";
        // qDebug()<<"读取IO输入输出";
        modbusConnect->readIO_DisInput();
        setKnifeA(modbusConnect->knifeA);
        setKnifeB(modbusConnect->knifeB);
        setRollerA(modbusConnect->rollerA);
        setRollerB(modbusConnect->rollerB);
        setScramBtn(modbusConnect->scramBtn);
        // setRollerOrigin(modbusConnect->rollerOrigin);
        // setKnifeUpLmt(modbusConnect->knifeUpLmt);
        // setKnifeDownLmt(modbusConnect->knifeDownLmt);
        // setTransducerWarnning(modbusConnect->transducerWarnning);
        setKnifeUpBtn(modbusConnect->knifeUpBtn);
        setKnifeDownBtn(modbusConnect->knifeDownBtn);
        setRollerUpBtn(modbusConnect->rollerUpBtn);
        setRollerDownBtn(modbusConnect->rollerDownBtn);

        modbusConnect->readIO_Coils();
        setKnifeUpSignal(modbusConnect->knifeUpSignal);
        setKnifeDownSignal(modbusConnect->knifeDownSignal);
        setRollerUpSignal(modbusConnect->rollerUpSignal);
        setRollerDownSignal(modbusConnect->rollerDownSignal);
        setManualControlSignal(modbusConnect->manualControlSignal);
        setRunningSignal(modbusConnect->runningSignal);
        // setWarnningSignal(modbusConnect->warnningSignal);
        break;
    case 6:     //  报警信息界面
        qDebug()<<"处于报警信息界面";
        break;
    case 7:     // 错误代码界面
        // qDebug()<<"读取错误代码";
        modbusConnect->readErrCode();
        setStress01_ErrCode(modbusConnect->stress01_ErrCode);
        setStress02_ErrCode(modbusConnect->stress02_ErrCode);
        setStress03_ErrCode(modbusConnect->stress03_ErrCode);
        setF_knife01_ErrCode(modbusConnect->f_knife01_ErrCode);
        setF_knife02_ErrCode(modbusConnect->f_knife02_ErrCode);
        setF_knife03_ErrCode(modbusConnect->f_knife03_ErrCode);
        setB_knife01_ErrCode(modbusConnect->b_knife01_ErrCode);
        setB_knife02_ErrCode(modbusConnect->b_knife02_ErrCode);
        setB_knife03_ErrCode(modbusConnect->b_knife03_ErrCode);
        break;
    case 8:     // 常用参数界面
        // qDebug()<<"读取常用参数";
        modbusConnect->readAutoAndManualSpeed();
        setStressMaunalSpeed(modbusConnect->stress_ManualSpeed);
        setStressAutoSpeed(modbusConnect->stress_AutoSpeed);
        setKnifeManualSpeed(modbusConnect->knife_ManualSpeed);
        setKnifeAutoSpeed(modbusConnect->knife_AutoSpeed);
        modbusConnect->readB_KnifeOffset();
        setB_knife01_Offset(modbusConnect->b_knife01_Offset);
        setB_knife02_Offset(modbusConnect->b_knife02_Offset);
        setB_knife03_Offset(modbusConnect->b_knife03_Offset);
        break;
    case 9:     // 待命点设置界面
        // qDebug()<<"读取待命点";
        modbusConnect->readStandbyLocation();
        setKnifeStandby(modbusConnect->knife_StandbyLocation);
        setRollerStandby(modbusConnect->roller_StandbyLocation);
        setStress01Standby(modbusConnect->stress01_StandbyLocation);
        setStress02Standby(modbusConnect->stress02_StandbyLocation);
        setStress03Standby(modbusConnect->stress03_StandbyLocation);
        setF_knife01Standby(modbusConnect->f_knife01_StandbyLocation);
        setF_knife02Standby(modbusConnect->f_knife02_StandbyLocation);
        setF_knife03Standby(modbusConnect->f_knife03_StandbyLocation);
        setB_knife01Standby(modbusConnect->b_knife01_StandbyLocation);
        setB_knife02Standby(modbusConnect->b_knife02_StandbyLocation);
        setB_knife03Standby(modbusConnect->b_knife03_StandbyLocation);
        break;
    case 10:    // 原点设置界面
        // qDebug()<<"读取原点位置";
        modbusConnect->readOriginLocation();
        setKnifeOriginLocation(modbusConnect->knife_OriginLocation);
        setRollerOriginLocation(modbusConnect->roller_OriginLocation);
        setStress01OriginLocation(modbusConnect->stress01_OriginLocation);
        setStress02OriginLocation(modbusConnect->stress02_OriginLocation);
        setStress03OriginLocation(modbusConnect->stress03_OriginLocation);
        setF_knife01OriginLocation(modbusConnect->f_knife01_OriginLocation);
        setF_knife02OriginLocation(modbusConnect->f_knife02_OriginLocation);
        setF_knife03OriginLocation(modbusConnect->f_knife03_OriginLocation);
        setB_knife01OriginLocation(modbusConnect->b_knife01_OriginLocation);
        setB_knife02OriginLocation(modbusConnect->b_knife02_OriginLocation);
        setB_knife03OriginLocation(modbusConnect->b_knife03_OriginLocation);
        break;
    case 11:    // 限位设置界面
        // qDebug()<<"读取限位位置";
        modbusConnect->readLimitLocation();
        setKnifeUpLimit(modbusConnect->knife_UpLimit);
        setKnifeDownLimit(modbusConnect->knife_DownLimit);
        setRollerUpLimit(modbusConnect->roller_UpLimit);
        setRollerDownLimit(modbusConnect->roller_DownLimit);
        setStress01_F_Limit(modbusConnect->stress01_F_Limit);
        setStress01_B_Limit(modbusConnect->stress01_B_Limit);
        setStress02_F_Limit(modbusConnect->stress02_F_Limit);
        setStress02_B_Limit(modbusConnect->stress02_B_Limit);
        setStress03_F_Limit(modbusConnect->stress03_F_Limit);
        setStress03_B_Limit(modbusConnect->stress03_B_Limit);
        setF_knife01_UpLimit(modbusConnect->f_knife01_UpLimit);
        setF_knife01_DownLimit(modbusConnect->f_knife01_DownLimit);
        setF_knife02_UpLimit(modbusConnect->f_knife02_UpLimit);
        setF_knife02_DownLimit(modbusConnect->f_knife02_DownLimit);
        setF_knife03_UpLimit(modbusConnect->f_knife03_UpLimit);
        setF_knife03_DownLimit(modbusConnect->f_knife03_DownLimit);
        setB_knife01_UpLimit(modbusConnect->b_knife01_UpLimit);
        setB_knife01_DownLimit(modbusConnect->b_knife01_DownLimit);
        setB_knife02_UpLimit(modbusConnect->b_knife02_UpLimit);
        setB_knife02_DownLimit(modbusConnect->b_knife02_DownLimit);
        setB_knife03_UpLimit(modbusConnect->b_knife03_UpLimit);
        setB_knife03_DownLimit(modbusConnect->b_knife03_DownLimit);
        break;
    case 12:    // 补偿设置界面
        // qDebug()<<"读取补偿位置";
        modbusConnect->readCompensate();
        setKnife_UpCpst(modbusConnect->knife_UpCpst);
        setKnife_DownCpst(modbusConnect->knife_DownCpst);
        setRoller_UpCpst(modbusConnect->roller_UpCpst);
        setRoller_DownCpst(modbusConnect->roller_DownCpst);
        setStress01_F_Cpst(modbusConnect->stress01_F_Cpst);
        setStress01_B_Cpst(modbusConnect->stress01_B_Cpst);
        setStress02_F_Cpst(modbusConnect->stress02_F_Cpst);
        setStress02_B_Cpst(modbusConnect->stress02_B_Cpst);
        setStress03_F_Cpst(modbusConnect->stress03_F_Cpst);
        setStress03_B_Cpst(modbusConnect->stress03_B_Cpst);
        setF_knife01_UpCpst(modbusConnect->f_knife01_UpCpst);
        setF_knife01_DownCpst(modbusConnect->f_knife01_DownCpst);
        setF_knife02_UpCpst(modbusConnect->f_knife02_UpCpst);
        setF_knife02_DownCpst(modbusConnect->f_knife02_DownCpst);
        setF_knife03_UpCpst(modbusConnect->f_knife03_UpCpst);
        setF_knife03_DownCpst(modbusConnect->f_knife03_DownCpst);
        setB_knife01_UpCpst(modbusConnect->b_knife01_UpCpst);
        setB_knife01_DownCpst(modbusConnect->b_knife01_DownCpst);
        setB_knife02_UpCpst(modbusConnect->b_knife02_UpCpst);
        setB_knife02_DownCpst(modbusConnect->b_knife02_DownCpst);
        setB_knife03_UpCpst(modbusConnect->b_knife03_UpCpst);
        setB_knife03_DownCpst(modbusConnect->b_knife03_DownCpst);
        break;
    case 13:    // 复位界面
        // qDebug()<<"读取当前位置";
        modbusConnect->readCurrentLocation();
        setKnifeCurrLocation(modbusConnect->knife_CurrLocation);
        setRollerCurrLocation(modbusConnect->roller_CurrLocation);
        setStress01CurrLocation(modbusConnect->stress01_CurrLocation);
        setStress02CurrLocation(modbusConnect->stress02_CurrLocation);
        setStress03CurrLocation(modbusConnect->stress03_CurrLocation);
        setF_knife01CurrLocation(modbusConnect->f_knife01_CurrLocation);
        setF_knife02CurrLocation(modbusConnect->f_knife02_CurrLocation);
        setF_knife03CurrLocation(modbusConnect->f_knife03_CurrLocation);
        setB_knife01CurrLocation(modbusConnect->b_knife01_CurrLocation);
        setB_knife02CurrLocation(modbusConnect->b_knife02_CurrLocation);
        setB_knife03CurrLocation(modbusConnect->b_knife03_CurrLocation);
        break;
    default:
        modbusConnect->readVersoinDescription();
        setVersion_Description(modbusConnect->vertion_Description);
        break;
    }
}

void ConnectManager::onModbusStateChanged_Slots(QModbusDevice::State state)
{
    switch(state)
    {
    case QModbusDevice::UnconnectedState:
        // qDebug()<<"连接失败";
        // 设置连接状态
        setModbusState(false);
        break;
    case QModbusDevice::ConnectingState:
        // qDebug()<<"连接中。。。";
        setModbusState(false);
        break;
    case QModbusDevice::ConnectedState:
        // qDebug()<<"连接成功!!!";
        setModbusState(true);
        break;
    case QModbusDevice::ClosingState:
        // qDebug()<<"断开连接";
        setModbusState(false);
        break;
    default:
        break;
    }
}

void ConnectManager::onScannerResult_Slots()
{
    qDebug()<<"扫码枪扫描事件触发";
    QByteArray buffer = scannerConnect->scannerSerial->readAll();

    QString scanResult = QString::fromLocal8Bit(buffer);

    QStringList resultList = scanResult.split(",");

    // 调用 一键写入函数
    modbusConnect->AutomaticPanel_OneKeyWriteParameter(resultList[0],resultList[1],
                                                       resultList[2],resultList[3],resultList[4],
                                                       resultList[5],resultList[6],resultList[7],
                                                       resultList[8],resultList[9],resultList[10]);
}



QString ConnectManager::knifeCurrLocation() const
{
    return m_knifeCurrLocation;
}

void ConnectManager::setKnifeCurrLocation(const QString &newKnifeCurrLocation)
{
    if (m_knifeCurrLocation == newKnifeCurrLocation)
        return;
    m_knifeCurrLocation = newKnifeCurrLocation;
    emit knifeCurrLocationChanged();
}

QString ConnectManager::rollerCurrLocation() const
{
    return m_rollerCurrLocation;
}

void ConnectManager::setRollerCurrLocation(const QString &newRollerCurrLocation)
{
    if (m_rollerCurrLocation == newRollerCurrLocation)
        return;
    m_rollerCurrLocation = newRollerCurrLocation;
    emit rollerCurrLocationChanged();
}

QString ConnectManager::stress01CurrLocation() const
{
    return m_stress01CurrLocation;
}

void ConnectManager::setStress01CurrLocation(const QString &newStress01CurrLocation)
{
    if (m_stress01CurrLocation == newStress01CurrLocation)
        return;
    m_stress01CurrLocation = newStress01CurrLocation;
    emit stress01CurrLocationChanged();
}

QString ConnectManager::stress02CurrLocation() const
{
    return m_stress02CurrLocation;
}

void ConnectManager::setStress02CurrLocation(const QString &newStress02CurrLocation)
{
    if (m_stress02CurrLocation == newStress02CurrLocation)
        return;
    m_stress02CurrLocation = newStress02CurrLocation;
    emit stress02CurrLocationChanged();
}

QString ConnectManager::stress03CurrLocation() const
{
    return m_stress03CurrLocation;
}

void ConnectManager::setStress03CurrLocation(const QString &newStress03CurrLocation)
{
    if (m_stress03CurrLocation == newStress03CurrLocation)
        return;
    m_stress03CurrLocation = newStress03CurrLocation;
    emit stress03CurrLocationChanged();
}

QString ConnectManager::f_knife01CurrLocation() const
{
    return m_f_knife01CurrLocation;
}

void ConnectManager::setF_knife01CurrLocation(const QString &newF_knife01CurrLocation)
{
    if (m_f_knife01CurrLocation == newF_knife01CurrLocation)
        return;
    m_f_knife01CurrLocation = newF_knife01CurrLocation;
    emit f_knife01CurrLocationChanged();
}

QString ConnectManager::f_knife02CurrLocation() const
{
    return m_f_knife02CurrLocation;
}

void ConnectManager::setF_knife02CurrLocation(const QString &newF_knife02CurrLocation)
{
    if (m_f_knife02CurrLocation == newF_knife02CurrLocation)
        return;
    m_f_knife02CurrLocation = newF_knife02CurrLocation;
    emit f_knife02CurrLocationChanged();
}

QString ConnectManager::f_knife03CurrLocation() const
{
    return m_f_knife03CurrLocation;
}

void ConnectManager::setF_knife03CurrLocation(const QString &newF_knife03CurrLocation)
{
    if (m_f_knife03CurrLocation == newF_knife03CurrLocation)
        return;
    m_f_knife03CurrLocation = newF_knife03CurrLocation;
    emit f_knife03CurrLocationChanged();
}

QString ConnectManager::b_knife01CurrLocation() const
{
    return m_b_knife01CurrLocation;
}

void ConnectManager::setB_knife01CurrLocation(const QString &newB_knife01CurrLocation)
{
    if (m_b_knife01CurrLocation == newB_knife01CurrLocation)
        return;
    m_b_knife01CurrLocation = newB_knife01CurrLocation;
    emit b_knife01CurrLocationChanged();
}

QString ConnectManager::b_knife02CurrLocation() const
{
    return m_b_knife02CurrLocation;
}

void ConnectManager::setB_knife02CurrLocation(const QString &newB_knife02CurrLocation)
{
    if (m_b_knife02CurrLocation == newB_knife02CurrLocation)
        return;
    m_b_knife02CurrLocation = newB_knife02CurrLocation;
    emit b_knife02CurrLocationChanged();
}

QString ConnectManager::b_knife03CurrLocation() const
{
    return m_b_knife03CurrLocation;
}

void ConnectManager::setB_knife03CurrLocation(const QString &newB_knife03CurrLocation)
{
    if (m_b_knife03CurrLocation == newB_knife03CurrLocation)
        return;
    m_b_knife03CurrLocation = newB_knife03CurrLocation;
    emit b_knife03CurrLocationChanged();
}

int ConnectManager::qmlPage() const
{
    return m_qmlPage;
}

void ConnectManager::setQmlPage(int newQmlPage)
{
    if (m_qmlPage == newQmlPage)
        return;
    m_qmlPage = newQmlPage;
    emit qmlPageChanged();
}

QString ConnectManager::knifeAimLocation() const
{
    return m_knifeAimLocation;
}

void ConnectManager::setKnifeAimLocation(const QString &newKnifeAimLocation)
{
    if (m_knifeAimLocation == newKnifeAimLocation)
        return;
    m_knifeAimLocation = newKnifeAimLocation;
    emit knifeAimLocationChanged();
}

QString ConnectManager::rollerAimLocation() const
{
    return m_rollerAimLocation;
}

void ConnectManager::setRollerAimLocation(const QString &newRollerAimLocation)
{
    if (m_rollerAimLocation == newRollerAimLocation)
        return;
    m_rollerAimLocation = newRollerAimLocation;
    emit rollerAimLocationChanged();
}

QString ConnectManager::stress01AimLocation() const
{
    return m_stress01AimLocation;
}

void ConnectManager::setStress01AimLocation(const QString &newStress01AimLocation)
{
    if (m_stress01AimLocation == newStress01AimLocation)
        return;
    m_stress01AimLocation = newStress01AimLocation;
    emit stress01AimLocationChanged();
}

QString ConnectManager::stress02AimLocation() const
{
    return m_stress02AimLocation;
}

void ConnectManager::setStress02AimLocation(const QString &newStress02AimLocation)
{
    if (m_stress02AimLocation == newStress02AimLocation)
        return;
    m_stress02AimLocation = newStress02AimLocation;
    emit stress02AimLocationChanged();
}

QString ConnectManager::stress03AimLocation() const
{
    return m_stress03AimLocation;
}

void ConnectManager::setStress03AimLocation(const QString &newStress03AimLocation)
{
    if (m_stress03AimLocation == newStress03AimLocation)
        return;
    m_stress03AimLocation = newStress03AimLocation;
    emit stress03AimLocationChanged();
}

QString ConnectManager::f_knife01AimLocation() const
{
    return m_f_knife01AimLocation;
}

void ConnectManager::setF_knife01AimLocation(const QString &newF_knife01AimLocation)
{
    if (m_f_knife01AimLocation == newF_knife01AimLocation)
        return;
    m_f_knife01AimLocation = newF_knife01AimLocation;
    emit f_knife01AimLocationChanged();
}

QString ConnectManager::f_knife02AimLocation() const
{
    return m_f_knife02AimLocation;
}

void ConnectManager::setF_knife02AimLocation(const QString &newF_knife02AimLocation)
{
    if (m_f_knife02AimLocation == newF_knife02AimLocation)
        return;
    m_f_knife02AimLocation = newF_knife02AimLocation;
    emit f_knife02AimLocationChanged();
}

QString ConnectManager::f_knife03AimLocation() const
{
    return m_f_knife03AimLocation;
}

void ConnectManager::setF_knife03AimLocation(const QString &newF_knife03AimLocation)
{
    if (m_f_knife03AimLocation == newF_knife03AimLocation)
        return;
    m_f_knife03AimLocation = newF_knife03AimLocation;
    emit f_knife03AimLocationChanged();
}

QString ConnectManager::b_knife01AimLocation() const
{
    return m_b_knife01AimLocation;
}

void ConnectManager::setB_knife01AimLocation(const QString &newB_knife01AimLocation)
{
    if (m_b_knife01AimLocation == newB_knife01AimLocation)
        return;
    m_b_knife01AimLocation = newB_knife01AimLocation;
    emit b_knife01AimLocationChanged();
}

QString ConnectManager::b_knife02AimLocation() const
{
    return m_b_knife02AimLocation;
}

void ConnectManager::setB_knife02AimLocation(const QString &newB_knife02AimLocation)
{
    if (m_b_knife02AimLocation == newB_knife02AimLocation)
        return;
    m_b_knife02AimLocation = newB_knife02AimLocation;
    emit b_knife02AimLocationChanged();
}

QString ConnectManager::b_knife03AimLocation() const
{
    return m_b_knife03AimLocation;
}

void ConnectManager::setB_knife03AimLocation(const QString &newB_knife03AimLocation)
{
    if (m_b_knife03AimLocation == newB_knife03AimLocation)
        return;
    m_b_knife03AimLocation = newB_knife03AimLocation;
    emit b_knife03AimLocationChanged();
}

QString ConnectManager::knifeStandby() const
{
    return m_knifeStandby;
}

void ConnectManager::setKnifeStandby(const QString &newKnifeStandby)
{
    if (m_knifeStandby == newKnifeStandby)
        return;
    m_knifeStandby = newKnifeStandby;
    emit knifeStandbyChanged();
}

QString ConnectManager::rollerStandby() const
{
    return m_rollerStandby;
}

void ConnectManager::setRollerStandby(const QString &newRollerStandby)
{
    if (m_rollerStandby == newRollerStandby)
        return;
    m_rollerStandby = newRollerStandby;
    emit rollerStandbyChanged();
}

QString ConnectManager::stress01Standby() const
{
    return m_stress01Standby;
}

void ConnectManager::setStress01Standby(const QString &newStress01Standby)
{
    if (m_stress01Standby == newStress01Standby)
        return;
    m_stress01Standby = newStress01Standby;
    emit stress01StandbyChanged();
}

QString ConnectManager::stress02Standby() const
{
    return m_stress02Standby;
}

void ConnectManager::setStress02Standby(const QString &newStress02Standby)
{
    if (m_stress02Standby == newStress02Standby)
        return;
    m_stress02Standby = newStress02Standby;
    emit stress02StandbyChanged();
}

QString ConnectManager::stress03Standby() const
{
    return m_stress03Standby;
}

void ConnectManager::setStress03Standby(const QString &newStress03Standby)
{
    if (m_stress03Standby == newStress03Standby)
        return;
    m_stress03Standby = newStress03Standby;
    emit stress03StandbyChanged();
}

QString ConnectManager::f_knife01Standby() const
{
    return m_f_knife01Standby;
}

void ConnectManager::setF_knife01Standby(const QString &newF_knife01Standby)
{
    if (m_f_knife01Standby == newF_knife01Standby)
        return;
    m_f_knife01Standby = newF_knife01Standby;
    emit f_knife01StandbyChanged();
}

QString ConnectManager::f_knife02Standby() const
{
    return m_f_knife02Standby;
}

void ConnectManager::setF_knife02Standby(const QString &newF_knife02Standby)
{
    if (m_f_knife02Standby == newF_knife02Standby)
        return;
    m_f_knife02Standby = newF_knife02Standby;
    emit f_knife02StandbyChanged();
}

QString ConnectManager::f_knife03Standby() const
{
    return m_f_knife03Standby;
}

void ConnectManager::setF_knife03Standby(const QString &newF_knife03Standby)
{
    if (m_f_knife03Standby == newF_knife03Standby)
        return;
    m_f_knife03Standby = newF_knife03Standby;
    emit f_knife03StandbyChanged();
}

QString ConnectManager::b_knife01Standby() const
{
    return m_b_knife01Standby;
}

void ConnectManager::setB_knife01Standby(const QString &newB_knife01Standby)
{
    if (m_b_knife01Standby == newB_knife01Standby)
        return;
    m_b_knife01Standby = newB_knife01Standby;
    emit b_knife01StandbyChanged();
}

QString ConnectManager::b_knife02Standby() const
{
    return m_b_knife02Standby;
}

void ConnectManager::setB_knife02Standby(const QString &newB_knife02Standby)
{
    if (m_b_knife02Standby == newB_knife02Standby)
        return;
    m_b_knife02Standby = newB_knife02Standby;
    emit b_knife02StandbyChanged();
}

QString ConnectManager::b_knife03Standby() const
{
    return m_b_knife03Standby;
}

void ConnectManager::setB_knife03Standby(const QString &newB_knife03Standby)
{
    if (m_b_knife03Standby == newB_knife03Standby)
        return;
    m_b_knife03Standby = newB_knife03Standby;
    emit b_knife03StandbyChanged();
}

QString ConnectManager::knifeLocation() const
{
    return m_knifeLocation;
}

void ConnectManager::setKnifeLocation(const QString &newKnifeLocation)
{
    if (m_knifeLocation == newKnifeLocation)
        return;
    m_knifeLocation = newKnifeLocation;
    emit knifeLocationChanged();
}

QString ConnectManager::rollerLocation() const
{
    return m_rollerLocation;
}

void ConnectManager::setRollerLocation(const QString &newRollerLocation)
{
    if (m_rollerLocation == newRollerLocation)
        return;
    m_rollerLocation = newRollerLocation;
    emit rollerLocationChanged();
}

QString ConnectManager::stress01Location() const
{
    return m_stress01Location;
}

void ConnectManager::setStress01Location(const QString &newStress01Location)
{
    if (m_stress01Location == newStress01Location)
        return;
    m_stress01Location = newStress01Location;
    emit stress01LocationChanged();
}

QString ConnectManager::stress02Location() const
{
    return m_stress02Location;
}

void ConnectManager::setStress02Location(const QString &newStress02Location)
{
    if (m_stress02Location == newStress02Location)
        return;
    m_stress02Location = newStress02Location;
    emit stress02LocationChanged();
}

QString ConnectManager::stress03Location() const
{
    return m_stress03Location;
}

void ConnectManager::setStress03Location(const QString &newStress03Location)
{
    if (m_stress03Location == newStress03Location)
        return;
    m_stress03Location = newStress03Location;
    emit stress03LocationChanged();
}

QString ConnectManager::f_knife01Location() const
{
    return m_f_knife01Location;
}

void ConnectManager::setF_knife01Location(const QString &newF_knife01Location)
{
    if (m_f_knife01Location == newF_knife01Location)
        return;
    m_f_knife01Location = newF_knife01Location;
    emit f_knife01LocationChanged();
}

QString ConnectManager::f_knife02Location() const
{
    return m_f_knife02Location;
}

void ConnectManager::setF_knife02Location(const QString &newF_knife02Location)
{
    if (m_f_knife02Location == newF_knife02Location)
        return;
    m_f_knife02Location = newF_knife02Location;
    emit f_knife02LocationChanged();
}

QString ConnectManager::f_knife03Location() const
{
    return m_f_knife03Location;
}

void ConnectManager::setF_knife03Location(const QString &newF_knife03Location)
{
    if (m_f_knife03Location == newF_knife03Location)
        return;
    m_f_knife03Location = newF_knife03Location;
    emit f_knife03LocationChanged();
}

QString ConnectManager::b_knife01Location() const
{
    return m_b_knife01Location;
}

void ConnectManager::setB_knife01Location(const QString &newB_knife01Location)
{
    if (m_b_knife01Location == newB_knife01Location)
        return;
    m_b_knife01Location = newB_knife01Location;
    emit b_knife01LocationChanged();
}

QString ConnectManager::b_knife02Location() const
{
    return m_b_knife02Location;
}

void ConnectManager::setB_knife02Location(const QString &newB_knife02Location)
{
    if (m_b_knife02Location == newB_knife02Location)
        return;
    m_b_knife02Location = newB_knife02Location;
    emit b_knife02LocationChanged();
}

QString ConnectManager::b_knife03Location() const
{
    return m_b_knife03Location;
}

void ConnectManager::setB_knife03Location(const QString &newB_knife03Location)
{
    if (m_b_knife03Location == newB_knife03Location)
        return;
    m_b_knife03Location = newB_knife03Location;
    emit b_knife03LocationChanged();
}

QString ConnectManager::stress01_ErrCode() const
{
    return m_stress01_ErrCode;
}

void ConnectManager::setStress01_ErrCode(const QString &newStress01_ErrCode)
{
    if (m_stress01_ErrCode == newStress01_ErrCode)
        return;
    m_stress01_ErrCode = newStress01_ErrCode;
    emit stress01_ErrCodeChanged();
}

QString ConnectManager::stress02_ErrCode() const
{
    return m_stress02_ErrCode;
}

void ConnectManager::setStress02_ErrCode(const QString &newStress02_ErrCode)
{
    if (m_stress02_ErrCode == newStress02_ErrCode)
        return;
    m_stress02_ErrCode = newStress02_ErrCode;
    emit stress02_ErrCodeChanged();
}

QString ConnectManager::stress03_ErrCode() const
{
    return m_stress03_ErrCode;
}

void ConnectManager::setStress03_ErrCode(const QString &newStress03_ErrCode)
{
    if (m_stress03_ErrCode == newStress03_ErrCode)
        return;
    m_stress03_ErrCode = newStress03_ErrCode;
    emit stress03_ErrCodeChanged();
}

QString ConnectManager::f_knife01_ErrCode() const
{
    return m_f_knife01_ErrCode;
}

void ConnectManager::setF_knife01_ErrCode(const QString &newF_knife01_ErrCode)
{
    if (m_f_knife01_ErrCode == newF_knife01_ErrCode)
        return;
    m_f_knife01_ErrCode = newF_knife01_ErrCode;
    emit f_knife01_ErrCodeChanged();
}

QString ConnectManager::f_knife02_ErrCode() const
{
    return m_f_knife02_ErrCode;
}

void ConnectManager::setF_knife02_ErrCode(const QString &newF_knife02_ErrCode)
{
    if (m_f_knife02_ErrCode == newF_knife02_ErrCode)
        return;
    m_f_knife02_ErrCode = newF_knife02_ErrCode;
    emit f_knife02_ErrCodeChanged();
}

QString ConnectManager::f_knife03_ErrCode() const
{
    return m_f_knife03_ErrCode;
}

void ConnectManager::setF_knife03_ErrCode(const QString &newF_knife03_ErrCode)
{
    if (m_f_knife03_ErrCode == newF_knife03_ErrCode)
        return;
    m_f_knife03_ErrCode = newF_knife03_ErrCode;
    emit f_knife03_ErrCodeChanged();
}

QString ConnectManager::b_knife01_ErrCode() const
{
    return m_b_knife01_ErrCode;
}

void ConnectManager::setB_knife01_ErrCode(const QString &newB_knife01_ErrCode)
{
    if (m_b_knife01_ErrCode == newB_knife01_ErrCode)
        return;
    m_b_knife01_ErrCode = newB_knife01_ErrCode;
    emit b_knife01_ErrCodeChanged();
}

QString ConnectManager::b_knife02_ErrCode() const
{
    return m_b_knife02_ErrCode;
}

void ConnectManager::setB_knife02_ErrCode(const QString &newB_knife02_ErrCode)
{
    if (m_b_knife02_ErrCode == newB_knife02_ErrCode)
        return;
    m_b_knife02_ErrCode = newB_knife02_ErrCode;
    emit b_knife02_ErrCodeChanged();
}

QString ConnectManager::b_knife03_ErrCode() const
{
    return m_b_knife03_ErrCode;
}

void ConnectManager::setB_knife03_ErrCode(const QString &newB_knife03_ErrCode)
{
    if (m_b_knife03_ErrCode == newB_knife03_ErrCode)
        return;
    m_b_knife03_ErrCode = newB_knife03_ErrCode;
    emit b_knife03_ErrCodeChanged();
}

bool ConnectManager::knifeA() const
{
    return m_knifeA;
}

void ConnectManager::setKnifeA(bool newKnifeA)
{
    if (m_knifeA == newKnifeA)
        return;
    m_knifeA = newKnifeA;
    emit knifeAChanged();
}

bool ConnectManager::knifeB() const
{
    return m_knifeB;
}

void ConnectManager::setKnifeB(bool newKnifeB)
{
    if (m_knifeB == newKnifeB)
        return;
    m_knifeB = newKnifeB;
    emit knifeBChanged();
}

bool ConnectManager::rollerA() const
{
    return m_rollerA;
}

void ConnectManager::setRollerA(bool newRollerA)
{
    if (m_rollerA == newRollerA)
        return;
    m_rollerA = newRollerA;
    emit rollerAChanged();
}

bool ConnectManager::rollerB() const
{
    return m_rollerB;
}

void ConnectManager::setRollerB(bool newRollerB)
{
    if (m_rollerB == newRollerB)
        return;
    m_rollerB = newRollerB;
    emit rollerBChanged();
}

bool ConnectManager::scramBtn() const
{
    return m_scramBtn;
}

void ConnectManager::setScramBtn(bool newScramBtn)
{
    if (m_scramBtn == newScramBtn)
        return;
    m_scramBtn = newScramBtn;
    emit scramBtnChanged();
}

bool ConnectManager::rollerOrigin() const
{
    return m_rollerOrigin;
}

void ConnectManager::setRollerOrigin(bool newRollerOrigin)
{
    if (m_rollerOrigin == newRollerOrigin)
        return;
    m_rollerOrigin = newRollerOrigin;
    emit rollerOriginChanged();
}

bool ConnectManager::knifeUpLmt() const
{
    return m_knifeUpLmt;
}

void ConnectManager::setKnifeUpLmt(bool newKnifeUpLmt)
{
    if (m_knifeUpLmt == newKnifeUpLmt)
        return;
    m_knifeUpLmt = newKnifeUpLmt;
    emit knifeUpLmtChanged();
}

bool ConnectManager::knifeDownLmt() const
{
    return m_knifeDownLmt;
}

void ConnectManager::setKnifeDownLmt(bool newKnifeDownLmt)
{
    if (m_knifeDownLmt == newKnifeDownLmt)
        return;
    m_knifeDownLmt = newKnifeDownLmt;
    emit knifeDownLmtChanged();
}

bool ConnectManager::transducerWarnning() const
{
    return m_transducerWarnning;
}

void ConnectManager::setTransducerWarnning(bool newTransducerWarnning)
{
    if (m_transducerWarnning == newTransducerWarnning)
        return;
    m_transducerWarnning = newTransducerWarnning;
    emit transducerWarnningChanged();
}

bool ConnectManager::knifeUpBtn() const
{
    return m_knifeUpBtn;
}

void ConnectManager::setKnifeUpBtn(bool newKnifeUpBtn)
{
    if (m_knifeUpBtn == newKnifeUpBtn)
        return;
    m_knifeUpBtn = newKnifeUpBtn;
    emit knifeUpBtnChanged();
}

bool ConnectManager::knifeDownBtn() const
{
    return m_knifeDownBtn;
}

void ConnectManager::setKnifeDownBtn(bool newKnifeDownBtn)
{
    if (m_knifeDownBtn == newKnifeDownBtn)
        return;
    m_knifeDownBtn = newKnifeDownBtn;
    emit knifeDownBtnChanged();
}

bool ConnectManager::rollerUpBtn() const
{
    return m_rollerUpBtn;
}

void ConnectManager::setRollerUpBtn(bool newRollerUpBtn)
{
    if (m_rollerUpBtn == newRollerUpBtn)
        return;
    m_rollerUpBtn = newRollerUpBtn;
    emit rollerUpBtnChanged();
}

bool ConnectManager::rollerDownBtn() const
{
    return m_rollerDownBtn;
}

void ConnectManager::setRollerDownBtn(bool newRollerDownBtn)
{
    if (m_rollerDownBtn == newRollerDownBtn)
        return;
    m_rollerDownBtn = newRollerDownBtn;
    emit rollerDownBtnChanged();
}

bool ConnectManager::knifeUpSignal() const
{
    return m_knifeUpSignal;
}

void ConnectManager::setKnifeUpSignal(bool newKnifeUpSignal)
{
    if (m_knifeUpSignal == newKnifeUpSignal)
        return;
    m_knifeUpSignal = newKnifeUpSignal;
    emit knifeUpSignalChanged();
}

bool ConnectManager::knifeDownSignal() const
{
    return m_knifeDownSignal;
}

void ConnectManager::setKnifeDownSignal(bool newKnifeDownSignal)
{
    if (m_knifeDownSignal == newKnifeDownSignal)
        return;
    m_knifeDownSignal = newKnifeDownSignal;
    emit knifeDownSignalChanged();
}

bool ConnectManager::rollerUpSignal() const
{
    return m_rollerUpSignal;
}

void ConnectManager::setRollerUpSignal(bool newRollerUpSignal)
{
    if (m_rollerUpSignal == newRollerUpSignal)
        return;
    m_rollerUpSignal = newRollerUpSignal;
    emit rollerUpSignalChanged();
}

bool ConnectManager::rollerDownSignal() const
{
    return m_rollerDownSignal;
}

void ConnectManager::setRollerDownSignal(bool newRollerDownSignal)
{
    if (m_rollerDownSignal == newRollerDownSignal)
        return;
    m_rollerDownSignal = newRollerDownSignal;
    emit rollerDownSignalChanged();
}

bool ConnectManager::manualControlSignal() const
{
    return m_manualControlSignal;
}

void ConnectManager::setManualControlSignal(bool newManualControlSignal)
{
    if (m_manualControlSignal == newManualControlSignal)
        return;
    m_manualControlSignal = newManualControlSignal;
    emit manualControlSignalChanged();
}

bool ConnectManager::runningSignal() const
{
    return m_runningSignal;
}

void ConnectManager::setRunningSignal(bool newRunningSignal)
{
    if (m_runningSignal == newRunningSignal)
        return;
    m_runningSignal = newRunningSignal;
    emit runningSignalChanged();
}

bool ConnectManager::warnningSignal() const
{
    return m_warnningSignal;
}

void ConnectManager::setWarnningSignal(bool newWarnningSignal)
{
    if (m_warnningSignal == newWarnningSignal)
        return;
    m_warnningSignal = newWarnningSignal;
    emit warnningSignalChanged();
}

QString ConnectManager::stressMaunalSpeed() const
{
    return m_stressMaunalSpeed;
}

void ConnectManager::setStressMaunalSpeed(const QString &newStressMaunalSpeed)
{
    if (m_stressMaunalSpeed == newStressMaunalSpeed)
        return;
    m_stressMaunalSpeed = newStressMaunalSpeed;
    emit stressMaunalSpeedChanged();
}

QString ConnectManager::stressAutoSpeed() const
{
    return m_stressAutoSpeed;
}

void ConnectManager::setStressAutoSpeed(const QString &newStressAutoSpeed)
{
    if (m_stressAutoSpeed == newStressAutoSpeed)
        return;
    m_stressAutoSpeed = newStressAutoSpeed;
    emit stressAutoSpeedChanged();
}

QString ConnectManager::knifeManualSpeed() const
{
    return m_knifeManualSpeed;
}

void ConnectManager::setKnifeManualSpeed(const QString &newKnifeManualSpeed)
{
    if (m_knifeManualSpeed == newKnifeManualSpeed)
        return;
    m_knifeManualSpeed = newKnifeManualSpeed;
    emit knifeManualSpeedChanged();
}

QString ConnectManager::knifeAutoSpeed() const
{
    return m_knifeAutoSpeed;
}

void ConnectManager::setKnifeAutoSpeed(const QString &newKnifeAutoSpeed)
{
    if (m_knifeAutoSpeed == newKnifeAutoSpeed)
        return;
    m_knifeAutoSpeed = newKnifeAutoSpeed;
    emit knifeAutoSpeedChanged();
}

QString ConnectManager::b_knife01_Offset() const
{
    return m_b_knife01_Offset;
}

void ConnectManager::setB_knife01_Offset(const QString &newB_knife01_Offset)
{
    if (m_b_knife01_Offset == newB_knife01_Offset)
        return;
    m_b_knife01_Offset = newB_knife01_Offset;
    emit b_knife01_OffsetChanged();
}

QString ConnectManager::b_knife02_Offset() const
{
    return m_b_knife02_Offset;
}

void ConnectManager::setB_knife02_Offset(const QString &newB_knife02_Offset)
{
    if (m_b_knife02_Offset == newB_knife02_Offset)
        return;
    m_b_knife02_Offset = newB_knife02_Offset;
    emit b_knife02_OffsetChanged();
}

QString ConnectManager::b_knife03_Offset() const
{
    return m_b_knife03_Offset;
}

void ConnectManager::setB_knife03_Offset(const QString &newB_knife03_Offset)
{
    if (m_b_knife03_Offset == newB_knife03_Offset)
        return;
    m_b_knife03_Offset = newB_knife03_Offset;
    emit b_knife03_OffsetChanged();
}

QString ConnectManager::knifeOriginLocation() const
{
    return m_knifeOriginLocation;
}

void ConnectManager::setKnifeOriginLocation(const QString &newKnifeOriginLocation)
{
    if (m_knifeOriginLocation == newKnifeOriginLocation)
        return;
    m_knifeOriginLocation = newKnifeOriginLocation;
    emit knifeOriginLocationChanged();
}

QString ConnectManager::rollerOriginLocation() const
{
    return m_rollerOriginLocation;
}

void ConnectManager::setRollerOriginLocation(const QString &newRollerOriginLocation)
{
    if (m_rollerOriginLocation == newRollerOriginLocation)
        return;
    m_rollerOriginLocation = newRollerOriginLocation;
    emit rollerOriginLocationChanged();
}

QString ConnectManager::stress01OriginLocation() const
{
    return m_stress01OriginLocation;
}

void ConnectManager::setStress01OriginLocation(const QString &newStress01OriginLocation)
{
    if (m_stress01OriginLocation == newStress01OriginLocation)
        return;
    m_stress01OriginLocation = newStress01OriginLocation;
    emit stress01OriginLocationChanged();
}

QString ConnectManager::stress02OriginLocation() const
{
    return m_stress02OriginLocation;
}

void ConnectManager::setStress02OriginLocation(const QString &newStress02OriginLocation)
{
    if (m_stress02OriginLocation == newStress02OriginLocation)
        return;
    m_stress02OriginLocation = newStress02OriginLocation;
    emit stress02OriginLocationChanged();
}

QString ConnectManager::f_knife01OriginLocation() const
{
    return m_f_knife01OriginLocation;
}

void ConnectManager::setF_knife01OriginLocation(const QString &newF_knife01OriginLocation)
{
    if (m_f_knife01OriginLocation == newF_knife01OriginLocation)
        return;
    m_f_knife01OriginLocation = newF_knife01OriginLocation;
    emit f_knife01OriginLocationChanged();
}

QString ConnectManager::f_knife02OriginLocation() const
{
    return m_f_knife02OriginLocation;
}

void ConnectManager::setF_knife02OriginLocation(const QString &newF_knife02OriginLocation)
{
    if (m_f_knife02OriginLocation == newF_knife02OriginLocation)
        return;
    m_f_knife02OriginLocation = newF_knife02OriginLocation;
    emit f_knife02OriginLocationChanged();
}

QString ConnectManager::f_knife03OriginLocation() const
{
    return m_f_knife03OriginLocation;
}

void ConnectManager::setF_knife03OriginLocation(const QString &newF_knife03OriginLocation)
{
    if (m_f_knife03OriginLocation == newF_knife03OriginLocation)
        return;
    m_f_knife03OriginLocation = newF_knife03OriginLocation;
    emit f_knife03OriginLocationChanged();
}

QString ConnectManager::b_knife01OriginLocation() const
{
    return m_b_knife01OriginLocation;
}

void ConnectManager::setB_knife01OriginLocation(const QString &newB_knife01OriginLocation)
{
    if (m_b_knife01OriginLocation == newB_knife01OriginLocation)
        return;
    m_b_knife01OriginLocation = newB_knife01OriginLocation;
    emit b_knife01OriginLocationChanged();
}

QString ConnectManager::b_knife02OriginLocation() const
{
    return m_b_knife02OriginLocation;
}

void ConnectManager::setB_knife02OriginLocation(const QString &newB_knife02OriginLocation)
{
    if (m_b_knife02OriginLocation == newB_knife02OriginLocation)
        return;
    m_b_knife02OriginLocation = newB_knife02OriginLocation;
    emit b_knife02OriginLocationChanged();
}

QString ConnectManager::b_knife03OriginLocation() const
{
    return m_b_knife03OriginLocation;
}

void ConnectManager::setB_knife03OriginLocation(const QString &newB_knife03OriginLocation)
{
    if (m_b_knife03OriginLocation == newB_knife03OriginLocation)
        return;
    m_b_knife03OriginLocation = newB_knife03OriginLocation;
    emit b_knife03OriginLocationChanged();
}

QString ConnectManager::stress03OriginLocation() const
{
    return m_stress03OriginLocation;
}

void ConnectManager::setStress03OriginLocation(const QString &newStress03OriginLocation)
{
    if (m_stress03OriginLocation == newStress03OriginLocation)
        return;
    m_stress03OriginLocation = newStress03OriginLocation;
    emit stress03OriginLocationChanged();
}

QString ConnectManager::knifeUpLimit() const
{
    return m_knifeUpLimit;
}

void ConnectManager::setKnifeUpLimit(const QString &newKnifeUpLimit)
{
    if (m_knifeUpLimit == newKnifeUpLimit)
        return;
    m_knifeUpLimit = newKnifeUpLimit;
    emit knifeUpLimitChanged();
}

QString ConnectManager::knifeDownLimit() const
{
    return m_knifeDownLimit;
}

void ConnectManager::setKnifeDownLimit(const QString &newKnifeDownLimit)
{
    if (m_knifeDownLimit == newKnifeDownLimit)
        return;
    m_knifeDownLimit = newKnifeDownLimit;
    emit knifeDownLimitChanged();
}

QString ConnectManager::rollerUpLimit() const
{
    return m_rollerUpLimit;
}

void ConnectManager::setRollerUpLimit(const QString &newRollerUpLimit)
{
    if (m_rollerUpLimit == newRollerUpLimit)
        return;
    m_rollerUpLimit = newRollerUpLimit;
    emit rollerUpLimitChanged();
}

QString ConnectManager::rollerDownLimit() const
{
    return m_rollerDownLimit;
}

void ConnectManager::setRollerDownLimit(const QString &newRollerDownLimit)
{
    if (m_rollerDownLimit == newRollerDownLimit)
        return;
    m_rollerDownLimit = newRollerDownLimit;
    emit rollerDownLimitChanged();
}

QString ConnectManager::stress01_F_Limit() const
{
    return m_stress01_F_Limit;
}

void ConnectManager::setStress01_F_Limit(const QString &newStress01_F_Limit)
{
    if (m_stress01_F_Limit == newStress01_F_Limit)
        return;
    m_stress01_F_Limit = newStress01_F_Limit;
    emit stress01_F_LimitChanged();
}

QString ConnectManager::stress01_B_Limit() const
{
    return m_stress01_B_Limit;
}

void ConnectManager::setStress01_B_Limit(const QString &newStress01_B_Limit)
{
    if (m_stress01_B_Limit == newStress01_B_Limit)
        return;
    m_stress01_B_Limit = newStress01_B_Limit;
    emit stress01_B_LimitChanged();
}

QString ConnectManager::stress02_F_Limit() const
{
    return m_stress02_F_Limit;
}

void ConnectManager::setStress02_F_Limit(const QString &newStress02_F_Limit)
{
    if (m_stress02_F_Limit == newStress02_F_Limit)
        return;
    m_stress02_F_Limit = newStress02_F_Limit;
    emit stress02_F_LimitChanged();
}

QString ConnectManager::stress02_B_Limit() const
{
    return m_stress02_B_Limit;
}

void ConnectManager::setStress02_B_Limit(const QString &newStress02_B_Limit)
{
    if (m_stress02_B_Limit == newStress02_B_Limit)
        return;
    m_stress02_B_Limit = newStress02_B_Limit;
    emit stress02_B_LimitChanged();
}

QString ConnectManager::stress03_F_Limit() const
{
    return m_stress03_F_Limit;
}

void ConnectManager::setStress03_F_Limit(const QString &newStress03_F_Limit)
{
    if (m_stress03_F_Limit == newStress03_F_Limit)
        return;
    m_stress03_F_Limit = newStress03_F_Limit;
    emit stress03_F_LimitChanged();
}

QString ConnectManager::stress03_B_Limit() const
{
    return m_stress03_B_Limit;
}

void ConnectManager::setStress03_B_Limit(const QString &newStress03_B_Limit)
{
    if (m_stress03_B_Limit == newStress03_B_Limit)
        return;
    m_stress03_B_Limit = newStress03_B_Limit;
    emit stress03_B_LimitChanged();
}

QString ConnectManager::f_knife01_UpLimit() const
{
    return m_f_knife01_UpLimit;
}

void ConnectManager::setF_knife01_UpLimit(const QString &newF_knife01_UpLimit)
{
    if (m_f_knife01_UpLimit == newF_knife01_UpLimit)
        return;
    m_f_knife01_UpLimit = newF_knife01_UpLimit;
    emit f_knife01_UpLimitChanged();
}

QString ConnectManager::f_knife01_DownLimit() const
{
    return m_f_knife01_DownLimit;
}

void ConnectManager::setF_knife01_DownLimit(const QString &newF_knife01_DownLimit)
{
    if (m_f_knife01_DownLimit == newF_knife01_DownLimit)
        return;
    m_f_knife01_DownLimit = newF_knife01_DownLimit;
    emit f_knife01_DownLimitChanged();
}

QString ConnectManager::f_knife02_UpLimit() const
{
    return m_f_knife02_UpLimit;
}

void ConnectManager::setF_knife02_UpLimit(const QString &newF_knife02_UpLimit)
{
    if (m_f_knife02_UpLimit == newF_knife02_UpLimit)
        return;
    m_f_knife02_UpLimit = newF_knife02_UpLimit;
    emit f_knife02_UpLimitChanged();
}

QString ConnectManager::f_knife02_DownLimit() const
{
    return m_f_knife02_DownLimit;
}

void ConnectManager::setF_knife02_DownLimit(const QString &newF_knife02_DownLimit)
{
    if (m_f_knife02_DownLimit == newF_knife02_DownLimit)
        return;
    m_f_knife02_DownLimit = newF_knife02_DownLimit;
    emit f_knife02_DownLimitChanged();
}

QString ConnectManager::f_knife03_UpLimit() const
{
    return m_f_knife03_UpLimit;
}

void ConnectManager::setF_knife03_UpLimit(const QString &newF_knife03_UpLimit)
{
    if (m_f_knife03_UpLimit == newF_knife03_UpLimit)
        return;
    m_f_knife03_UpLimit = newF_knife03_UpLimit;
    emit f_knife03_UpLimitChanged();
}

QString ConnectManager::f_knife03_DownLimit() const
{
    return m_f_knife03_DownLimit;
}

void ConnectManager::setF_knife03_DownLimit(const QString &newF_knife03_DownLimit)
{
    if (m_f_knife03_DownLimit == newF_knife03_DownLimit)
        return;
    m_f_knife03_DownLimit = newF_knife03_DownLimit;
    emit f_knife03_DownLimitChanged();
}

QString ConnectManager::b_knife01_UpLimit() const
{
    return m_b_knife01_UpLimit;
}

void ConnectManager::setB_knife01_UpLimit(const QString &newB_knife01_UpLimit)
{
    if (m_b_knife01_UpLimit == newB_knife01_UpLimit)
        return;
    m_b_knife01_UpLimit = newB_knife01_UpLimit;
    emit b_knife01_UpLimitChanged();
}

QString ConnectManager::b_knife01_DownLimit() const
{
    return m_b_knife01_DownLimit;
}

void ConnectManager::setB_knife01_DownLimit(const QString &newB_knife01_DownLimit)
{
    if (m_b_knife01_DownLimit == newB_knife01_DownLimit)
        return;
    m_b_knife01_DownLimit = newB_knife01_DownLimit;
    emit b_knife01_DownLimitChanged();
}

QString ConnectManager::b_knife02_UpLimit() const
{
    return m_b_knife02_UpLimit;
}

void ConnectManager::setB_knife02_UpLimit(const QString &newB_knife02_UpLimit)
{
    if (m_b_knife02_UpLimit == newB_knife02_UpLimit)
        return;
    m_b_knife02_UpLimit = newB_knife02_UpLimit;
    emit b_knife02_UpLimitChanged();
}

QString ConnectManager::b_knife02_DownLimit() const
{
    return m_b_knife02_DownLimit;
}

void ConnectManager::setB_knife02_DownLimit(const QString &newB_knife02_DownLimit)
{
    if (m_b_knife02_DownLimit == newB_knife02_DownLimit)
        return;
    m_b_knife02_DownLimit = newB_knife02_DownLimit;
    emit b_knife02_DownLimitChanged();
}

QString ConnectManager::b_knife03_UpLimit() const
{
    return m_b_knife03_UpLimit;
}

void ConnectManager::setB_knife03_UpLimit(const QString &newB_knife03_UpLimit)
{
    if (m_b_knife03_UpLimit == newB_knife03_UpLimit)
        return;
    m_b_knife03_UpLimit = newB_knife03_UpLimit;
    emit b_knife03_UpLimitChanged();
}

QString ConnectManager::b_knife03_DownLimit() const
{
    return m_b_knife03_DownLimit;
}

void ConnectManager::setB_knife03_DownLimit(const QString &newB_knife03_DownLimit)
{
    if (m_b_knife03_DownLimit == newB_knife03_DownLimit)
        return;
    m_b_knife03_DownLimit = newB_knife03_DownLimit;
    emit b_knife03_DownLimitChanged();
}

QString ConnectManager::knife_UpCpst() const
{
    return m_knife_UpCpst;
}

void ConnectManager::setKnife_UpCpst(const QString &newKnife_UpCpst)
{
    if (m_knife_UpCpst == newKnife_UpCpst)
        return;
    m_knife_UpCpst = newKnife_UpCpst;
    emit knife_UpCpstChanged();
}

QString ConnectManager::knife_DownCpst() const
{
    return m_knife_DownCpst;
}

void ConnectManager::setKnife_DownCpst(const QString &newKnife_DownCpst)
{
    if (m_knife_DownCpst == newKnife_DownCpst)
        return;
    m_knife_DownCpst = newKnife_DownCpst;
    emit knife_DownCpstChanged();
}

QString ConnectManager::roller_UpCpst() const
{
    return m_roller_UpCpst;
}

void ConnectManager::setRoller_UpCpst(const QString &newRoller_UpCpst)
{
    if (m_roller_UpCpst == newRoller_UpCpst)
        return;
    m_roller_UpCpst = newRoller_UpCpst;
    emit roller_UpCpstChanged();
}

QString ConnectManager::roller_DownCpst() const
{
    return m_roller_DownCpst;
}

void ConnectManager::setRoller_DownCpst(const QString &newRoller_DownCpst)
{
    if (m_roller_DownCpst == newRoller_DownCpst)
        return;
    m_roller_DownCpst = newRoller_DownCpst;
    emit roller_DownCpstChanged();
}

QString ConnectManager::stress01_F_Cpst() const
{
    return m_stress01_F_Cpst;
}

void ConnectManager::setStress01_F_Cpst(const QString &newStress01_F_Cpst)
{
    if (m_stress01_F_Cpst == newStress01_F_Cpst)
        return;
    m_stress01_F_Cpst = newStress01_F_Cpst;
    emit stress01_F_CpstChanged();
}

QString ConnectManager::stress01_B_Cpst() const
{
    return m_stress01_B_Cpst;
}

void ConnectManager::setStress01_B_Cpst(const QString &newStress01_B_Cpst)
{
    if (m_stress01_B_Cpst == newStress01_B_Cpst)
        return;
    m_stress01_B_Cpst = newStress01_B_Cpst;
    emit stress01_B_CpstChanged();
}

QString ConnectManager::stress02_F_Cpst() const
{
    return m_stress02_F_Cpst;
}

void ConnectManager::setStress02_F_Cpst(const QString &newStress02_F_Cpst)
{
    if (m_stress02_F_Cpst == newStress02_F_Cpst)
        return;
    m_stress02_F_Cpst = newStress02_F_Cpst;
    emit stress02_F_CpstChanged();
}

QString ConnectManager::stress02_B_Cpst() const
{
    return m_stress02_B_Cpst;
}

void ConnectManager::setStress02_B_Cpst(const QString &newStress02_B_Cpst)
{
    if (m_stress02_B_Cpst == newStress02_B_Cpst)
        return;
    m_stress02_B_Cpst = newStress02_B_Cpst;
    emit stress02_B_CpstChanged();
}

QString ConnectManager::stress03_F_Cpst() const
{
    return m_stress03_F_Cpst;
}

void ConnectManager::setStress03_F_Cpst(const QString &newStress03_F_Cpst)
{
    if (m_stress03_F_Cpst == newStress03_F_Cpst)
        return;
    m_stress03_F_Cpst = newStress03_F_Cpst;
    emit stress03_F_CpstChanged();
}

QString ConnectManager::stress03_B_Cpst() const
{
    return m_stress03_B_Cpst;
}

void ConnectManager::setStress03_B_Cpst(const QString &newStress03_B_Cpst)
{
    if (m_stress03_B_Cpst == newStress03_B_Cpst)
        return;
    m_stress03_B_Cpst = newStress03_B_Cpst;
    emit stress03_B_CpstChanged();
}

QString ConnectManager::f_knife01_UpCpst() const
{
    return m_f_knife01_UpCpst;
}

void ConnectManager::setF_knife01_UpCpst(const QString &newF_knife01_UpCpst)
{
    if (m_f_knife01_UpCpst == newF_knife01_UpCpst)
        return;
    m_f_knife01_UpCpst = newF_knife01_UpCpst;
    emit f_knife01_UpCpstChanged();
}

QString ConnectManager::f_knife01_DownCpst() const
{
    return m_f_knife01_DownCpst;
}

void ConnectManager::setF_knife01_DownCpst(const QString &newF_knife01_DownCpst)
{
    if (m_f_knife01_DownCpst == newF_knife01_DownCpst)
        return;
    m_f_knife01_DownCpst = newF_knife01_DownCpst;
    emit f_knife01_DownCpstChanged();
}

QString ConnectManager::f_knife02_UpCpst() const
{
    return m_f_knife02_UpCpst;
}

void ConnectManager::setF_knife02_UpCpst(const QString &newF_knife02_UpCpst)
{
    if (m_f_knife02_UpCpst == newF_knife02_UpCpst)
        return;
    m_f_knife02_UpCpst = newF_knife02_UpCpst;
    emit f_knife02_UpCpstChanged();
}

QString ConnectManager::f_knife02_DownCpst() const
{
    return m_f_knife02_DownCpst;
}

void ConnectManager::setF_knife02_DownCpst(const QString &newF_knife02_DownCpst)
{
    if (m_f_knife02_DownCpst == newF_knife02_DownCpst)
        return;
    m_f_knife02_DownCpst = newF_knife02_DownCpst;
    emit f_knife02_DownCpstChanged();
}

QString ConnectManager::f_knife03_UpCpst() const
{
    return m_f_knife03_UpCpst;
}

void ConnectManager::setF_knife03_UpCpst(const QString &newF_knife03_UpCpst)
{
    if (m_f_knife03_UpCpst == newF_knife03_UpCpst)
        return;
    m_f_knife03_UpCpst = newF_knife03_UpCpst;
    emit f_knife03_UpCpstChanged();
}

QString ConnectManager::f_knife03_DownCpst() const
{
    return m_f_knife03_DownCpst;
}

void ConnectManager::setF_knife03_DownCpst(const QString &newF_knife03_DownCpst)
{
    if (m_f_knife03_DownCpst == newF_knife03_DownCpst)
        return;
    m_f_knife03_DownCpst = newF_knife03_DownCpst;
    emit f_knife03_DownCpstChanged();
}

QString ConnectManager::b_knife01_UpCpst() const
{
    return m_b_knife01_UpCpst;
}

void ConnectManager::setB_knife01_UpCpst(const QString &newB_knife01_UpCpst)
{
    if (m_b_knife01_UpCpst == newB_knife01_UpCpst)
        return;
    m_b_knife01_UpCpst = newB_knife01_UpCpst;
    emit b_knife01_UpCpstChanged();
}

QString ConnectManager::b_knife01_DownCpst() const
{
    return m_b_knife01_DownCpst;
}

void ConnectManager::setB_knife01_DownCpst(const QString &newB_knife01_DownCpst)
{
    if (m_b_knife01_DownCpst == newB_knife01_DownCpst)
        return;
    m_b_knife01_DownCpst = newB_knife01_DownCpst;
    emit b_knife01_DownCpstChanged();
}

QString ConnectManager::b_knife02_UpCpst() const
{
    return m_b_knife02_UpCpst;
}

void ConnectManager::setB_knife02_UpCpst(const QString &newB_knife02_UpCpst)
{
    if (m_b_knife02_UpCpst == newB_knife02_UpCpst)
        return;
    m_b_knife02_UpCpst = newB_knife02_UpCpst;
    emit b_knife02_UpCpstChanged();
}

QString ConnectManager::b_knife02_DownCpst() const
{
    return m_b_knife02_DownCpst;
}

void ConnectManager::setB_knife02_DownCpst(const QString &newB_knife02_DownCpst)
{
    if (m_b_knife02_DownCpst == newB_knife02_DownCpst)
        return;
    m_b_knife02_DownCpst = newB_knife02_DownCpst;
    emit b_knife02_DownCpstChanged();
}

QString ConnectManager::b_knife03_UpCpst() const
{
    return m_b_knife03_UpCpst;
}

void ConnectManager::setB_knife03_UpCpst(const QString &newB_knife03_UpCpst)
{
    if (m_b_knife03_UpCpst == newB_knife03_UpCpst)
        return;
    m_b_knife03_UpCpst = newB_knife03_UpCpst;
    emit b_knife03_UpCpstChanged();
}

QString ConnectManager::b_knife03_DownCpst() const
{
    return m_b_knife03_DownCpst;
}

void ConnectManager::setB_knife03_DownCpst(const QString &newB_knife03_DownCpst)
{
    if (m_b_knife03_DownCpst == newB_knife03_DownCpst)
        return;
    m_b_knife03_DownCpst = newB_knife03_DownCpst;
    emit b_knife03_DownCpstChanged();
}

QString ConnectManager::manualSpeedRate() const
{
    return m_manualSpeedRate;
}

void ConnectManager::setManualSpeedRate(const QString &newManualSpeedRate)
{
    if (m_manualSpeedRate == newManualSpeedRate)
        return;
    m_manualSpeedRate = newManualSpeedRate;
    emit manualSpeedRateChanged();
}

QString ConnectManager::transducerSpeed() const
{
    return m_transducerSpeed;
}

void ConnectManager::setTransducerSpeed(const QString &newTransducerSpeed)
{
    if (m_transducerSpeed == newTransducerSpeed)
        return;
    m_transducerSpeed = newTransducerSpeed;
    emit transducerSpeedChanged();
}

QString ConnectManager::scannerResult() const
{
    return m_scannerResult;
}

void ConnectManager::setScannerResult(const QString &newScannerResult)
{
    if (m_scannerResult == newScannerResult)
        return;
    m_scannerResult = newScannerResult;
    emit scannerResultChanged();
}

bool ConnectManager::knife_Up_SLmt() const
{
    return m_knife_Up_SLmt;
}

void ConnectManager::setKnife_Up_SLmt(bool newKnife_Up_SLmt)
{
    if (m_knife_Up_SLmt == newKnife_Up_SLmt)
        return;
    m_knife_Up_SLmt = newKnife_Up_SLmt;
    emit knife_Up_SLmtChanged();
}

bool ConnectManager::knife_Down_SLmt() const
{
    return m_knife_Down_SLmt;
}

void ConnectManager::setKnife_Down_SLmt(bool newKnife_Down_SLmt)
{
    if (m_knife_Down_SLmt == newKnife_Down_SLmt)
        return;
    m_knife_Down_SLmt = newKnife_Down_SLmt;
    emit knife_Down_SLmtChanged();
}

bool ConnectManager::roller_Up_SLmt() const
{
    return m_roller_Up_SLmt;
}

void ConnectManager::setRoller_Up_SLmt(bool newRoller_Up_SLmt)
{
    if (m_roller_Up_SLmt == newRoller_Up_SLmt)
        return;
    m_roller_Up_SLmt = newRoller_Up_SLmt;
    emit roller_Up_SLmtChanged();
}

bool ConnectManager::roller_Down_SLmt() const
{
    return m_roller_Down_SLmt;
}

void ConnectManager::setRoller_Down_SLmt(bool newRoller_Down_SLmt)
{
    if (m_roller_Down_SLmt == newRoller_Down_SLmt)
        return;
    m_roller_Down_SLmt = newRoller_Down_SLmt;
    emit roller_Down_SLmtChanged();
}

bool ConnectManager::stress01_F_SLmt() const
{
    return m_stress01_F_SLmt;
}

void ConnectManager::setStress01_F_SLmt(bool newStress01_F_SLmt)
{
    if (m_stress01_F_SLmt == newStress01_F_SLmt)
        return;
    m_stress01_F_SLmt = newStress01_F_SLmt;
    emit stress01_F_SLmtChanged();
}

bool ConnectManager::stress01_B_SLmt() const
{
    return m_stress01_B_SLmt;
}

void ConnectManager::setStress01_B_SLmt(bool newStress01_B_SLmt)
{
    if (m_stress01_B_SLmt == newStress01_B_SLmt)
        return;
    m_stress01_B_SLmt = newStress01_B_SLmt;
    emit stress01_B_SLmtChanged();
}

bool ConnectManager::stress02_F_SLmt() const
{
    return m_stress02_F_SLmt;
}

void ConnectManager::setStress02_F_SLmt(bool newStress02_F_SLmt)
{
    if (m_stress02_F_SLmt == newStress02_F_SLmt)
        return;
    m_stress02_F_SLmt = newStress02_F_SLmt;
    emit stress02_F_SLmtChanged();
}

bool ConnectManager::stress02_B_SLmt() const
{
    return m_stress02_B_SLmt;
}

void ConnectManager::setStress02_B_SLmt(bool newStress02_B_SLmt)
{
    if (m_stress02_B_SLmt == newStress02_B_SLmt)
        return;
    m_stress02_B_SLmt = newStress02_B_SLmt;
    emit stress02_B_SLmtChanged();
}

bool ConnectManager::stress03_F_SLmt() const
{
    return m_stress03_F_SLmt;
}

void ConnectManager::setStress03_F_SLmt(bool newStress03_F_SLmt)
{
    if (m_stress03_F_SLmt == newStress03_F_SLmt)
        return;
    m_stress03_F_SLmt = newStress03_F_SLmt;
    emit stress03_F_SLmtChanged();
}

bool ConnectManager::stress03_B_SLmt() const
{
    return m_stress03_B_SLmt;
}

void ConnectManager::setStress03_B_SLmt(bool newStress03_B_SLmt)
{
    if (m_stress03_B_SLmt == newStress03_B_SLmt)
        return;
    m_stress03_B_SLmt = newStress03_B_SLmt;
    emit stress03_B_SLmtChanged();
}

bool ConnectManager::f_knife01_Up_SLmt() const
{
    return m_f_knife01_Up_SLmt;
}

void ConnectManager::setF_knife01_Up_SLmt(bool newF_knife01_Up_SLmt)
{
    if (m_f_knife01_Up_SLmt == newF_knife01_Up_SLmt)
        return;
    m_f_knife01_Up_SLmt = newF_knife01_Up_SLmt;
    emit f_knife01_Up_SLmtChanged();
}

bool ConnectManager::f_knife01_Down_SLmt() const
{
    return m_f_knife01_Down_SLmt;
}

void ConnectManager::setF_knife01_Down_SLmt(bool newF_knife01_Down_SLmt)
{
    if (m_f_knife01_Down_SLmt == newF_knife01_Down_SLmt)
        return;
    m_f_knife01_Down_SLmt = newF_knife01_Down_SLmt;
    emit f_knife01_Down_SLmtChanged();
}

bool ConnectManager::f_knife02_Up_SLmt() const
{
    return m_f_knife02_Up_SLmt;
}

void ConnectManager::setF_knife02_Up_SLmt(bool newF_knife02_Up_SLmt)
{
    if (m_f_knife02_Up_SLmt == newF_knife02_Up_SLmt)
        return;
    m_f_knife02_Up_SLmt = newF_knife02_Up_SLmt;
    emit f_knife02_Up_SLmtChanged();
}

bool ConnectManager::f_knife02_Down_SLmt() const
{
    return m_f_knife02_Down_SLmt;
}

void ConnectManager::setF_knife02_Down_SLmt(bool newF_knife02_Down_SLmt)
{
    if (m_f_knife02_Down_SLmt == newF_knife02_Down_SLmt)
        return;
    m_f_knife02_Down_SLmt = newF_knife02_Down_SLmt;
    emit f_knife02_Down_SLmtChanged();
}

bool ConnectManager::f_knife03_Up_SLmt() const
{
    return m_f_knife03_Up_SLmt;
}

void ConnectManager::setF_knife03_Up_SLmt(bool newF_knife03_Up_SLmt)
{
    if (m_f_knife03_Up_SLmt == newF_knife03_Up_SLmt)
        return;
    m_f_knife03_Up_SLmt = newF_knife03_Up_SLmt;
    emit f_knife03_Up_SLmtChanged();
}

bool ConnectManager::f_knife03_Down_SLmt() const
{
    return m_f_knife03_Down_SLmt;
}

void ConnectManager::setF_knife03_Down_SLmt(bool newF_knife03_Down_SLmt)
{
    if (m_f_knife03_Down_SLmt == newF_knife03_Down_SLmt)
        return;
    m_f_knife03_Down_SLmt = newF_knife03_Down_SLmt;
    emit f_knife03_Down_SLmtChanged();
}

bool ConnectManager::b_knife01_Up_SLmt() const
{
    return m_b_knife01_Up_SLmt;
}

void ConnectManager::setB_knife01_Up_SLmt(bool newB_knife01_Up_SLmt)
{
    if (m_b_knife01_Up_SLmt == newB_knife01_Up_SLmt)
        return;
    m_b_knife01_Up_SLmt = newB_knife01_Up_SLmt;
    emit b_knife01_Up_SLmtChanged();
}

bool ConnectManager::b_knife01_Down_SLmt() const
{
    return m_b_knife01_Down_SLmt;
}

void ConnectManager::setB_knife01_Down_SLmt(bool newB_knife01_Down_SLmt)
{
    if (m_b_knife01_Down_SLmt == newB_knife01_Down_SLmt)
        return;
    m_b_knife01_Down_SLmt = newB_knife01_Down_SLmt;
    emit b_knife01_Down_SLmtChanged();
}

bool ConnectManager::b_knife02_Up_SLmt() const
{
    return m_b_knife02_Up_SLmt;
}

void ConnectManager::setB_knife02_Up_SLmt(bool newB_knife02_Up_SLmt)
{
    if (m_b_knife02_Up_SLmt == newB_knife02_Up_SLmt)
        return;
    m_b_knife02_Up_SLmt = newB_knife02_Up_SLmt;
    emit b_knife02_Up_SLmtChanged();
}

bool ConnectManager::b_knife02_Down_SLmt() const
{
    return m_b_knife02_Down_SLmt;
}

void ConnectManager::setB_knife02_Down_SLmt(bool newB_knife02_Down_SLmt)
{
    if (m_b_knife02_Down_SLmt == newB_knife02_Down_SLmt)
        return;
    m_b_knife02_Down_SLmt = newB_knife02_Down_SLmt;
    emit b_knife02_Down_SLmtChanged();
}

bool ConnectManager::b_knife03_Up_SLmt() const
{
    return m_b_knife03_Up_SLmt;
}

void ConnectManager::setB_knife03_Up_SLmt(bool newB_knife03_Up_SLmt)
{
    if (m_b_knife03_Up_SLmt == newB_knife03_Up_SLmt)
        return;
    m_b_knife03_Up_SLmt = newB_knife03_Up_SLmt;
    emit b_knife03_Up_SLmtChanged();
}

bool ConnectManager::b_knife03_Down_SLmt() const
{
    return m_b_knife03_Down_SLmt;
}

void ConnectManager::setB_knife03_Down_SLmt(bool newB_knife03_Down_SLmt)
{
    if (m_b_knife03_Down_SLmt == newB_knife03_Down_SLmt)
        return;
    m_b_knife03_Down_SLmt = newB_knife03_Down_SLmt;
    emit b_knife03_Down_SLmtChanged();
}



QString ConnectManager::Version_Description() const
{
    return m_Version_Description;
}

void ConnectManager::setVersion_Description(const QString &newVersion_Description)
{
    if (m_Version_Description == newVersion_Description)
        return;
    m_Version_Description = newVersion_Description;
    emit Version_DescriptionChanged();
}
